package acm.天梯赛4;

import 左哥算法.ch15并查集.UnionFindSet;

import java.util.*;

/**
 * 最小生成树
 */
public class F {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n;
        while ((n=sc.nextInt())!=0){
            Integer[][] edges=new Integer[n*(n-1)/2][3];
            for (Integer[] edge : edges) {
                edge[0]=sc.nextInt();
                edge[1]=sc.nextInt();
                edge[2]=sc.nextInt();
            }
            Graph graph = new Graph(edges);
//            System.out.println(fun(graph));
            System.out.println(fun2(graph));
        }
    }
    /**
     *  最小生成树p算法
     *  p算法思路：
     *      准备一个存放点的set集合和存放解锁边的优先级队列
     *      从任意一个点出发，对该点的边进行解锁，
     *      队列弹出解锁的边中最小的一条，如果这条边的to点没有被加载，
     *      则将这条边的to点保存起来，并将to点附近的边解锁，如果被解锁，则再找下一条边
     *      重复上两个步骤
     */
    public static int fun(Graph graph){
        int min=0;
        Set<Node> nodeSet=new HashSet<>();
        PriorityQueue<Edge> edges=new PriorityQueue<>((Comparator.comparingInt(o -> o.weight)));
        Node root = graph.nodes.get(1);
        nodeSet.add(root);
        edges.addAll(root.edges);
        while (nodeSet.size()<graph.nodes.size()){
            Edge edge = edges.poll();
            if (!nodeSet.contains(edge.to)) {
                min+=edge.weight;
                nodeSet.add(edge.to);
                edges.addAll(edge.to.edges);
            }
        }
        return min;
    }

    /**
     * 最小生成树k算法
     *  并查集思路（k算法）：
     *      用一个map存放每个节点的父节点（上一个连接自己的节点），如果没有节点连接自己，父节点则为自己
     *      对所有的边进行排序，对每次最小一条边的两头节点进行集合查找操作（查看两个节点是否存在共同的父节点）
     *          如果不存在则表示该边的两个节点没有连通，将两个节点的父节点设为同一个（已经连通）
     *          如果存在则表示有更小的边使这两个点连通，不需要当前边
     *      直到将所有边都筛选完毕
     */
    public static int fun2(Graph graph){
        int res=0;
        UnionFindSet<Node> unionSet=new UnionFindSet<>(graph.nodes.values());
        PriorityQueue<Edge> queue=new PriorityQueue<>((o1, o2) -> o1.weight-o2.weight);
        queue.addAll(graph.edges);
        while (!queue.isEmpty()){
            Edge edge = queue.poll();
            if (!unionSet.isSameSet(edge.from,edge.to)) {
                res+=edge.weight;
                unionSet.union(edge.from,edge.to);
            }
        }
        return res;
    }

    static class Graph{
        public Map<Integer, Node> nodes;
        public Set<Edge> edges;

        public Graph() {
            nodes=new HashMap<>();
            edges=new HashSet<>();
        }

        public Graph(Map<Integer, Node> nodes, Set<Edge> edges) {
            this.nodes = nodes;
            this.edges = edges;
        }

        /**
         * 根据邻接数组生成图
         */
        public Graph(Integer[][] arr) {
            this();
            for (Integer[] num : arr) {
                if (!nodes.containsKey(num[0])) {
                    nodes.put(num[0],new Node(num[0]));
                }
                if (!nodes.containsKey(num[1])) {
                    nodes.put(num[1],new Node(num[1]));
                }
            }
            for (Integer[] num : arr) {
                Node from = nodes.get(num[0]);
                Node to =nodes.get(num[1]);
                Edge edge1 = new Edge(num[2], from, to);
                from.edges.add(edge1);
                edges.add(edge1);
//                Edge edge2 = new Edge(num[2], to, from);
//                to.edges.add(edge2);
//                edges.add(edge2);
            }
        }
    }
    static class Edge {
        public Integer weight;
        public Node from;   //该边的入点
        public Node to;     //该边的出点

        public Edge(Integer weight, Node from, Node to) {
            this.weight = weight;
            this.from = from;
            this.to = to;
        }

        public Edge(Node from, Node to) {
            this.from = from;
            this.to = to;
        }
    }
    static class Node {
        public Integer val;
        int in; //入度：进入该点的个数
        int out;    //出度：该点走出的个数
        List<Node> nexts;    //该点的邻居
        List<Edge> edges;

        public Node(Integer val) {
            this.val = val;
            nexts=new ArrayList<>();
            edges=new ArrayList<>();
        }

        @Override
        public String toString() {
            return "Node{" +
                    "val=" + val +
                    '}';
        }
    }
}